extern "C" {
    typedef long unsigned int size_t;
    typedef unsigned char __u_char;
    typedef unsigned short int __u_short;
    typedef unsigned int __u_int;
    typedef unsigned long int __u_long;
    typedef signed char __int8_t;
    typedef unsigned char __uint8_t;
    typedef signed short int __int16_t;
    typedef unsigned short int __uint16_t;
    typedef signed int __int32_t;
    typedef unsigned int __uint32_t;
    typedef signed long int __int64_t;
    typedef unsigned long int __uint64_t;
    typedef long int __quad_t;
    typedef unsigned long int __u_quad_t;
    typedef unsigned long int __dev_t;
    typedef unsigned int __uid_t;
    typedef unsigned int __gid_t;
    typedef unsigned long int __ino_t;
    typedef unsigned long int __ino64_t;
    typedef unsigned int __mode_t;
    typedef unsigned long int __nlink_t;
    typedef long int __off_t;
    typedef long int __off64_t;
    typedef int __pid_t;
    typedef struct { int __val[2]; } __fsid_t;
    typedef long int __clock_t;
    typedef unsigned long int __rlim_t;
    typedef unsigned long int __rlim64_t;
    typedef unsigned int __id_t;
    typedef long int __time_t;
    typedef unsigned int __useconds_t;
    typedef long int __suseconds_t;
    typedef int __daddr_t;
    typedef long int __swblk_t;
    typedef int __key_t;
    typedef int __clockid_t;
    typedef void * __timer_t;
    typedef long int __blksize_t;
    typedef long int __blkcnt_t;
    typedef long int __blkcnt64_t;
    typedef unsigned long int __fsblkcnt_t;
    typedef unsigned long int __fsblkcnt64_t;
    typedef unsigned long int __fsfilcnt_t;
    typedef unsigned long int __fsfilcnt64_t;
    typedef long int __ssize_t;
    typedef __off64_t __loff_t;
    typedef __quad_t *__qaddr_t;
    typedef char *__caddr_t;
    typedef long int __intptr_t;
    typedef unsigned int __socklen_t;
    struct _IO_FILE;

    typedef struct _IO_FILE FILE;









    typedef struct _IO_FILE __FILE;
    typedef struct
    {
        int __count;
        union
        {
            unsigned int __wch;
            char __wchb[4];
        } __value;
    } __mbstate_t;
    typedef struct
    {
        __off_t __pos;
        __mbstate_t __state;
    } _G_fpos_t;
    typedef struct
    {
        __off64_t __pos;
        __mbstate_t __state;
    } _G_fpos64_t;
    typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
    typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
    typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
    typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
    typedef __builtin_va_list __gnuc_va_list;
    struct _IO_jump_t; struct _IO_FILE;
    typedef void _IO_lock_t;
    struct _IO_marker {
        struct _IO_marker *_next;
        struct _IO_FILE *_sbuf;
        int _pos;
    };
    enum __codecvt_result
    {
        __codecvt_ok,
        __codecvt_partial,
        __codecvt_error,
        __codecvt_noconv
    };
    struct _IO_FILE {
        int _flags;
        char* _IO_read_ptr;
        char* _IO_read_end;
        char* _IO_read_base;
        char* _IO_write_base;
        char* _IO_write_ptr;
        char* _IO_write_end;
        char* _IO_buf_base;
        char* _IO_buf_end;
        char *_IO_save_base;
        char *_IO_backup_base;
        char *_IO_save_end;
        struct _IO_marker *_markers;
        struct _IO_FILE *_chain;
        int _fileno;
        int _flags2;
        __off_t _old_offset;
        unsigned short _cur_column;
        signed char _vtable_offset;
        char _shortbuf[1];
        _IO_lock_t *_lock;
        __off64_t _offset;
        void *__pad1;
        void *__pad2;
        void *__pad3;
        void *__pad4;
        size_t __pad5;
        int _mode;
        char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
    };
    struct _IO_FILE_plus;
    extern struct _IO_FILE_plus _IO_2_1_stdin_;
    extern struct _IO_FILE_plus _IO_2_1_stdout_;
    extern struct _IO_FILE_plus _IO_2_1_stderr_;
    typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
    typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
            size_t __n);
    typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
    typedef int __io_close_fn (void *__cookie);
    typedef __io_read_fn cookie_read_function_t;
    typedef __io_write_fn cookie_write_function_t;
    typedef __io_seek_fn cookie_seek_function_t;
    typedef __io_close_fn cookie_close_function_t;
    typedef struct
    {
        __io_read_fn *read;
        __io_write_fn *write;
        __io_seek_fn *seek;
        __io_close_fn *close;
    } _IO_cookie_io_functions_t;
    typedef _IO_cookie_io_functions_t cookie_io_functions_t;
    struct _IO_cookie_file;
    extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
            void *__cookie, _IO_cookie_io_functions_t __fns);
    extern "C" {
        extern int __underflow (_IO_FILE *);
        extern int __uflow (_IO_FILE *);
        extern int __overflow (_IO_FILE *, int);
        extern int _IO_getc (_IO_FILE *__fp);
        extern int _IO_putc (int __c, _IO_FILE *__fp);
        extern int _IO_feof (_IO_FILE *__fp) throw ();
        extern int _IO_ferror (_IO_FILE *__fp) throw ();
        extern int _IO_peekc_locked (_IO_FILE *__fp);
        extern void _IO_flockfile (_IO_FILE *) throw ();
        extern void _IO_funlockfile (_IO_FILE *) throw ();
        extern int _IO_ftrylockfile (_IO_FILE *) throw ();
        extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                __gnuc_va_list, int *__restrict);
        extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                __gnuc_va_list);
        extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
        extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
        extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
        extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
        extern void _IO_free_backup_area (_IO_FILE *) throw ();
    }
    typedef __gnuc_va_list va_list;
    typedef __off_t off_t;
    typedef __off64_t off64_t;
    typedef __ssize_t ssize_t;

    typedef _G_fpos_t fpos_t;

    typedef _G_fpos64_t fpos64_t;
    extern struct _IO_FILE *stdin;
    extern struct _IO_FILE *stdout;
    extern struct _IO_FILE *stderr;

    extern int remove (__const char *__filename) throw ();
    extern int rename (__const char *__old, __const char *__new) throw ();

    extern int renameat (int __oldfd, __const char *__old, int __newfd,
            __const char *__new) throw ();

    extern FILE *tmpfile (void) ;




    extern FILE *tmpfile64 (void) ;



    extern char *tmpnam (char *__s) throw () ;





    extern char *tmpnam_r (char *__s) throw () ;
    extern char *tempnam (__const char *__dir, __const char *__pfx)
        throw () __attribute__ ((__malloc__)) ;

    extern int fclose (FILE *__stream);
    extern int fflush (FILE *__stream);

    extern int fflush_unlocked (FILE *__stream);
    extern int fcloseall (void);

    extern FILE *fopen (__const char *__restrict __filename,
            __const char *__restrict __modes) ;
    extern FILE *freopen (__const char *__restrict __filename,
            __const char *__restrict __modes,
            FILE *__restrict __stream) ;

    extern FILE *fopen64 (__const char *__restrict __filename,
            __const char *__restrict __modes) ;
    extern FILE *freopen64 (__const char *__restrict __filename,
            __const char *__restrict __modes,
            FILE *__restrict __stream) ;
    extern FILE *fdopen (int __fd, __const char *__modes) throw () ;
    extern FILE *fopencookie (void *__restrict __magic_cookie,
            __const char *__restrict __modes,
            _IO_cookie_io_functions_t __io_funcs) throw () ;
    extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
        throw () ;
    extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;

    extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
    extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
            int __modes, size_t __n) throw ();

    extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
            size_t __size) throw ();
    extern void setlinebuf (FILE *__stream) throw ();

    extern int fprintf (FILE *__restrict __stream,
            __const char *__restrict __format, ...);
    extern int printf (__const char *__restrict __format, ...);
    extern int sprintf (char *__restrict __s,
            __const char *__restrict __format, ...) throw ();
    extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
            __gnuc_va_list __arg);
    extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
    extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
            __gnuc_va_list __arg) throw ();


    extern int snprintf (char *__restrict __s, size_t __maxlen,
            __const char *__restrict __format, ...)
        throw () __attribute__ ((__format__ (__printf__, 3, 4)));
    extern int vsnprintf (char *__restrict __s, size_t __maxlen,
            __const char *__restrict __format, __gnuc_va_list __arg)
        throw () __attribute__ ((__format__ (__printf__, 3, 0)));

    extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
            __gnuc_va_list __arg)
        throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
    extern int __asprintf (char **__restrict __ptr,
            __const char *__restrict __fmt, ...)
        throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
    extern int asprintf (char **__restrict __ptr,
            __const char *__restrict __fmt, ...)
        throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
    extern int vdprintf (int __fd, __const char *__restrict __fmt,
            __gnuc_va_list __arg)
        __attribute__ ((__format__ (__printf__, 2, 0)));
    extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
        __attribute__ ((__format__ (__printf__, 2, 3)));

    extern int fscanf (FILE *__restrict __stream,
            __const char *__restrict __format, ...) ;
    extern int scanf (__const char *__restrict __format, ...) ;
    extern int sscanf (__const char *__restrict __s,
            __const char *__restrict __format, ...) throw ();


    extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
            __gnuc_va_list __arg)
        __attribute__ ((__format__ (__scanf__, 2, 0))) ;
    extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
        __attribute__ ((__format__ (__scanf__, 1, 0))) ;
    extern int vsscanf (__const char *__restrict __s,
            __const char *__restrict __format, __gnuc_va_list __arg)
        throw () __attribute__ ((__format__ (__scanf__, 2, 0)));


    extern int fgetc (FILE *__stream);
    extern int getc (FILE *__stream);
    extern int getchar (void);

    extern int getc_unlocked (FILE *__stream);
    extern int getchar_unlocked (void);
    extern int fgetc_unlocked (FILE *__stream);

    extern int fputc (int __c, FILE *__stream);
    extern int putc (int __c, FILE *__stream);
    extern int putchar (int __c);

    extern int fputc_unlocked (int __c, FILE *__stream);
    extern int putc_unlocked (int __c, FILE *__stream);
    extern int putchar_unlocked (int __c);
    extern int getw (FILE *__stream);
    extern int putw (int __w, FILE *__stream);

    extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
        ;
    extern char *gets (char *__s) ;

    extern char *fgets_unlocked (char *__restrict __s, int __n,
            FILE *__restrict __stream) ;
    extern __ssize_t __getdelim (char **__restrict __lineptr,
            size_t *__restrict __n, int __delimiter,
            FILE *__restrict __stream) ;
    extern __ssize_t getdelim (char **__restrict __lineptr,
            size_t *__restrict __n, int __delimiter,
            FILE *__restrict __stream) ;
    extern __ssize_t getline (char **__restrict __lineptr,
            size_t *__restrict __n,
            FILE *__restrict __stream) ;

    extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
    extern int puts (__const char *__s);
    extern int ungetc (int __c, FILE *__stream);
    extern size_t fread (void *__restrict __ptr, size_t __size,
            size_t __n, FILE *__restrict __stream) ;
    extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
            size_t __n, FILE *__restrict __s) ;

    extern int fputs_unlocked (__const char *__restrict __s,
            FILE *__restrict __stream);
    extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
            size_t __n, FILE *__restrict __stream) ;
    extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
            size_t __n, FILE *__restrict __stream) ;

    extern int fseek (FILE *__stream, long int __off, int __whence);
    extern long int ftell (FILE *__stream) ;
    extern void rewind (FILE *__stream);

    extern int fseeko (FILE *__stream, __off_t __off, int __whence);
    extern __off_t ftello (FILE *__stream) ;

    extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
    extern int fsetpos (FILE *__stream, __const fpos_t *__pos);

    extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
    extern __off64_t ftello64 (FILE *__stream) ;
    extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
    extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);

    extern void clearerr (FILE *__stream) throw ();
    extern int feof (FILE *__stream) throw () ;
    extern int ferror (FILE *__stream) throw () ;

    extern void clearerr_unlocked (FILE *__stream) throw ();
    extern int feof_unlocked (FILE *__stream) throw () ;
    extern int ferror_unlocked (FILE *__stream) throw () ;

    extern void perror (__const char *__s);

    extern int sys_nerr;
    extern __const char *__const sys_errlist[];
    extern int _sys_nerr;
    extern __const char *__const _sys_errlist[];
    extern int fileno (FILE *__stream) throw () ;
    extern int fileno_unlocked (FILE *__stream) throw () ;
    extern FILE *popen (__const char *__command, __const char *__modes) ;
    extern int pclose (FILE *__stream);
    extern char *ctermid (char *__s) throw ();
    extern char *cuserid (char *__s);
    struct obstack;
    extern int obstack_printf (struct obstack *__restrict __obstack,
            __const char *__restrict __format, ...)
        throw () __attribute__ ((__format__ (__printf__, 2, 3)));
    extern int obstack_vprintf (struct obstack *__restrict __obstack,
            __const char *__restrict __format,
            __gnuc_va_list __args)
        throw () __attribute__ ((__format__ (__printf__, 2, 0)));
    extern void flockfile (FILE *__stream) throw ();
    extern int ftrylockfile (FILE *__stream) throw () ;
    extern void funlockfile (FILE *__stream) throw ();
}
extern "C" {
    typedef double ev_tstamp;
    extern "C" {
        typedef int __sig_atomic_t;
        typedef struct
        {
            unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
        } __sigset_t;
        extern int __sigismember (__const __sigset_t *, int);
        extern int __sigaddset (__sigset_t *, int);
        extern int __sigdelset (__sigset_t *, int);

        typedef __sig_atomic_t sig_atomic_t;

        typedef __sigset_t sigset_t;
        typedef __pid_t pid_t;
        typedef __uid_t uid_t;
        struct timespec
        {
            __time_t tv_sec;
            long int tv_nsec;
        };
        typedef union sigval
        {
            int sival_int;
            void *sival_ptr;
        } sigval_t;
        typedef struct siginfo
        {
            int si_signo;
            int si_errno;
            int si_code;
            union
            {
                int _pad[((128 / sizeof (int)) - 4)];
                struct
                {
                    __pid_t si_pid;
                    __uid_t si_uid;
                } _kill;
                struct
                {
                    int si_tid;
                    int si_overrun;
                    sigval_t si_sigval;
                } _timer;
                struct
                {
                    __pid_t si_pid;
                    __uid_t si_uid;
                    sigval_t si_sigval;
                } _rt;
                struct
                {
                    __pid_t si_pid;
                    __uid_t si_uid;
                    int si_status;
                    __clock_t si_utime;
                    __clock_t si_stime;
                } _sigchld;
                struct
                {
                    void *si_addr;
                } _sigfault;
                struct
                {
                    long int si_band;
                    int si_fd;
                } _sigpoll;
            } _sifields;
        } siginfo_t;
        enum
        {
            SI_ASYNCNL = -60,
            SI_TKILL = -6,
            SI_SIGIO,
            SI_ASYNCIO,
            SI_MESGQ,
            SI_TIMER,
            SI_QUEUE,
            SI_USER,
            SI_KERNEL = 0x80
        };
        enum
        {
            ILL_ILLOPC = 1,
            ILL_ILLOPN,
            ILL_ILLADR,
            ILL_ILLTRP,
            ILL_PRVOPC,
            ILL_PRVREG,
            ILL_COPROC,
            ILL_BADSTK
        };
        enum
        {
            FPE_INTDIV = 1,
            FPE_INTOVF,
            FPE_FLTDIV,
            FPE_FLTOVF,
            FPE_FLTUND,
            FPE_FLTRES,
            FPE_FLTINV,
            FPE_FLTSUB
        };
        enum
        {
            SEGV_MAPERR = 1,
            SEGV_ACCERR
        };
        enum
        {
            BUS_ADRALN = 1,
            BUS_ADRERR,
            BUS_OBJERR
        };
        enum
        {
            TRAP_BRKPT = 1,
            TRAP_TRACE
        };
        enum
        {
            CLD_EXITED = 1,
            CLD_KILLED,
            CLD_DUMPED,
            CLD_TRAPPED,
            CLD_STOPPED,
            CLD_CONTINUED
        };
        enum
        {
            POLL_IN = 1,
            POLL_OUT,
            POLL_MSG,
            POLL_ERR,
            POLL_PRI,
            POLL_HUP
        };
        typedef struct sigevent
        {
            sigval_t sigev_value;
            int sigev_signo;
            int sigev_notify;
            union
            {
                int _pad[((64 / sizeof (int)) - 4)];
                __pid_t _tid;
                struct
                {
                    void (*_function) (sigval_t);
                    void *_attribute;
                } _sigev_thread;
            } _sigev_un;
        } sigevent_t;
        enum
        {
            SIGEV_SIGNAL = 0,
            SIGEV_NONE,
            SIGEV_THREAD,
            SIGEV_THREAD_ID = 4
        };
        typedef void (*__sighandler_t) (int);
        extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
            throw ();
        extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
            throw ();

        extern __sighandler_t signal (int __sig, __sighandler_t __handler)
            throw ();

        extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
            throw ();
        extern int kill (__pid_t __pid, int __sig) throw ();
        extern int killpg (__pid_t __pgrp, int __sig) throw ();

        extern int raise (int __sig) throw ();

        extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
            throw ();
        extern int gsignal (int __sig) throw ();
        extern void psignal (int __sig, __const char *__s);
        extern void psiginfo (__const siginfo_t *__pinfo, __const char *__s);
        extern int __sigpause (int __sig_or_mask, int __is_sig);
        extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
        extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
        extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
        extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
        typedef __sighandler_t sighandler_t;
        typedef __sighandler_t sig_t;
        extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigismember (__const sigset_t *__set, int __signo)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int sigisemptyset (__const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigandset (sigset_t *__set, __const sigset_t *__left,
                __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
        extern int sigorset (sigset_t *__set, __const sigset_t *__left,
                __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
        struct sigaction
        {
            union
            {
                __sighandler_t sa_handler;
                void (*sa_sigaction) (int, siginfo_t *, void *);
            }
            __sigaction_handler;
            __sigset_t sa_mask;
            int sa_flags;
            void (*sa_restorer) (void);
        };
        extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
                sigset_t *__restrict __oset) throw ();
        extern int sigsuspend (__const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
        extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
                struct sigaction *__restrict __oact) throw ();
        extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
        extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
            __attribute__ ((__nonnull__ (1, 2)));
        extern int sigwaitinfo (__const sigset_t *__restrict __set,
                siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
        extern int sigtimedwait (__const sigset_t *__restrict __set,
                siginfo_t *__restrict __info,
                __const struct timespec *__restrict __timeout)
            __attribute__ ((__nonnull__ (1)));
        extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
            throw ();
        extern __const char *__const _sys_siglist[65];
        extern __const char *__const sys_siglist[65];
        struct sigvec
        {
            __sighandler_t sv_handler;
            int sv_mask;
            int sv_flags;
        };
        extern int sigvec (int __sig, __const struct sigvec *__vec,
                struct sigvec *__ovec) throw ();
        struct _fpreg
        {
            unsigned short significand[4];
            unsigned short exponent;
        };
        struct _fpxreg
        {
            unsigned short significand[4];
            unsigned short exponent;
            unsigned short padding[3];
        };
        struct _xmmreg
        {
            __uint32_t element[4];
        };
        struct _fpstate
        {
            __uint16_t cwd;
            __uint16_t swd;
            __uint16_t ftw;
            __uint16_t fop;
            __uint64_t rip;
            __uint64_t rdp;
            __uint32_t mxcsr;
            __uint32_t mxcr_mask;
            struct _fpxreg _st[8];
            struct _xmmreg _xmm[16];
            __uint32_t padding[24];
        };
        struct sigcontext
        {
            unsigned long r8;
            unsigned long r9;
            unsigned long r10;
            unsigned long r11;
            unsigned long r12;
            unsigned long r13;
            unsigned long r14;
            unsigned long r15;
            unsigned long rdi;
            unsigned long rsi;
            unsigned long rbp;
            unsigned long rbx;
            unsigned long rdx;
            unsigned long rax;
            unsigned long rcx;
            unsigned long rsp;
            unsigned long rip;
            unsigned long eflags;
            unsigned short cs;
            unsigned short gs;
            unsigned short fs;
            unsigned short __pad0;
            unsigned long err;
            unsigned long trapno;
            unsigned long oldmask;
            unsigned long cr2;
            struct _fpstate * fpstate;
            unsigned long __reserved1 [8];
        };
        extern int sigreturn (struct sigcontext *__scp) throw ();
        extern int siginterrupt (int __sig, int __interrupt) throw ();
        struct sigstack
        {
            void *ss_sp;
            int ss_onstack;
        };
        enum
        {
            SS_ONSTACK = 1,
            SS_DISABLE
        };
        typedef struct sigaltstack
        {
            void *ss_sp;
            int ss_flags;
            size_t ss_size;
        } stack_t;
        typedef long int greg_t;
        typedef greg_t gregset_t[23];
        enum
        {
            REG_R8 = 0,
            REG_R9,
            REG_R10,
            REG_R11,
            REG_R12,
            REG_R13,
            REG_R14,
            REG_R15,
            REG_RDI,
            REG_RSI,
            REG_RBP,
            REG_RBX,
            REG_RDX,
            REG_RAX,
            REG_RCX,
            REG_RSP,
            REG_RIP,
            REG_EFL,
            REG_CSGSFS,
            REG_ERR,
            REG_TRAPNO,
            REG_OLDMASK,
            REG_CR2
        };
        struct _libc_fpxreg
        {
            unsigned short int significand[4];
            unsigned short int exponent;
            unsigned short int padding[3];
        };
        struct _libc_xmmreg
        {
            __uint32_t element[4];
        };
        struct _libc_fpstate
        {
            __uint16_t cwd;
            __uint16_t swd;
            __uint16_t ftw;
            __uint16_t fop;
            __uint64_t rip;
            __uint64_t rdp;
            __uint32_t mxcsr;
            __uint32_t mxcr_mask;
            struct _libc_fpxreg _st[8];
            struct _libc_xmmreg _xmm[16];
            __uint32_t padding[24];
        };
        typedef struct _libc_fpstate *fpregset_t;
        typedef struct
        {
            gregset_t gregs;
            fpregset_t fpregs;
            unsigned long __reserved1 [8];
        } mcontext_t;
        typedef struct ucontext
        {
            unsigned long int uc_flags;
            struct ucontext *uc_link;
            stack_t uc_stack;
            mcontext_t uc_mcontext;
            __sigset_t uc_sigmask;
            struct _libc_fpstate __fpregs_mem;
        } ucontext_t;
        extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
            throw () __attribute__ ((__deprecated__));
        extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
                struct sigaltstack *__restrict __oss) throw ();
        extern int sighold (int __sig) throw ();
        extern int sigrelse (int __sig) throw ();
        extern int sigignore (int __sig) throw ();
        extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
        typedef unsigned long int pthread_t;
        typedef union
        {
            char __size[56];
            long int __align;
        } pthread_attr_t;
        typedef struct __pthread_internal_list
        {
            struct __pthread_internal_list *__prev;
            struct __pthread_internal_list *__next;
        } __pthread_list_t;
        typedef union
        {
            struct __pthread_mutex_s
            {
                int __lock;
                unsigned int __count;
                int __owner;
                unsigned int __nusers;
                int __kind;
                int __spins;
                __pthread_list_t __list;
            } __data;
            char __size[40];
            long int __align;
        } pthread_mutex_t;
        typedef union
        {
            char __size[4];
            int __align;
        } pthread_mutexattr_t;
        typedef union
        {
            struct
            {
                int __lock;
                unsigned int __futex;
                __extension__ unsigned long long int __total_seq;
                __extension__ unsigned long long int __wakeup_seq;
                __extension__ unsigned long long int __woken_seq;
                void *__mutex;
                unsigned int __nwaiters;
                unsigned int __broadcast_seq;
            } __data;
            char __size[48];
            __extension__ long long int __align;
        } pthread_cond_t;
        typedef union
        {
            char __size[4];
            int __align;
        } pthread_condattr_t;
        typedef unsigned int pthread_key_t;
        typedef int pthread_once_t;
        typedef union
        {
            struct
            {
                int __lock;
                unsigned int __nr_readers;
                unsigned int __readers_wakeup;
                unsigned int __writer_wakeup;
                unsigned int __nr_readers_queued;
                unsigned int __nr_writers_queued;
                int __writer;
                int __shared;
                unsigned long int __pad1;
                unsigned long int __pad2;
                unsigned int __flags;
            } __data;
            char __size[56];
            long int __align;
        } pthread_rwlock_t;
        typedef union
        {
            char __size[8];
            long int __align;
        } pthread_rwlockattr_t;
        typedef volatile int pthread_spinlock_t;
        typedef union
        {
            char __size[32];
            long int __align;
        } pthread_barrier_t;
        typedef union
        {
            char __size[4];
            int __align;
        } pthread_barrierattr_t;
        extern int pthread_sigmask (int __how,
                __const __sigset_t *__restrict __newmask,
                __sigset_t *__restrict __oldmask)throw ();
        extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
        extern int pthread_sigqueue (pthread_t __threadid, int __signo,
                const union sigval __value) throw ();
        extern int __libc_current_sigrtmin (void) throw ();
        extern int __libc_current_sigrtmax (void) throw ();
    }

    typedef __time_t time_t;


    typedef __dev_t dev_t;
    typedef __gid_t gid_t;
    typedef __ino_t ino_t;
    typedef __mode_t mode_t;
    typedef __nlink_t nlink_t;
    typedef __blkcnt_t blkcnt_t;
    typedef __blksize_t blksize_t;
    extern "C" {
        struct stat
        {
            __dev_t st_dev;
            __ino_t st_ino;
            __nlink_t st_nlink;
            __mode_t st_mode;
            __uid_t st_uid;
            __gid_t st_gid;
            int __pad0;
            __dev_t st_rdev;
            __off_t st_size;
            __blksize_t st_blksize;
            __blkcnt_t st_blocks;
            struct timespec st_atim;
            struct timespec st_mtim;
            struct timespec st_ctim;
            long int __unused[3];
        };
        struct stat64
        {
            __dev_t st_dev;
            __ino64_t st_ino;
            __nlink_t st_nlink;
            __mode_t st_mode;
            __uid_t st_uid;
            __gid_t st_gid;
            int __pad0;
            __dev_t st_rdev;
            __off_t st_size;
            __blksize_t st_blksize;
            __blkcnt64_t st_blocks;
            struct timespec st_atim;
            struct timespec st_mtim;
            struct timespec st_ctim;
            long int __unused[3];
        };
        extern int stat (__const char *__restrict __file,
                struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
        extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
        extern int stat64 (__const char *__restrict __file,
                struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
        extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
        extern int fstatat (int __fd, __const char *__restrict __file,
                struct stat *__restrict __buf, int __flag)
            throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int fstatat64 (int __fd, __const char *__restrict __file,
                struct stat64 *__restrict __buf, int __flag)
            throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int lstat (__const char *__restrict __file,
                struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
        extern int lstat64 (__const char *__restrict __file,
                struct stat64 *__restrict __buf)
            throw () __attribute__ ((__nonnull__ (1, 2)));
        extern int chmod (__const char *__file, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int lchmod (__const char *__file, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int fchmod (int __fd, __mode_t __mode) throw ();
        extern int fchmodat (int __fd, __const char *__file, __mode_t __mode,
                int __flag)
            throw () __attribute__ ((__nonnull__ (2))) ;
        extern __mode_t umask (__mode_t __mask) throw ();
        extern __mode_t getumask (void) throw ();
        extern int mkdir (__const char *__path, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int mkdirat (int __fd, __const char *__path, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (2)));
        extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int mknodat (int __fd, __const char *__path, __mode_t __mode,
                __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
        extern int mkfifo (__const char *__path, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (1)));
        extern int mkfifoat (int __fd, __const char *__path, __mode_t __mode)
            throw () __attribute__ ((__nonnull__ (2)));
        extern int utimensat (int __fd, __const char *__path,
                __const struct timespec __times[2],
                int __flags)
            throw () __attribute__ ((__nonnull__ (2)));
        extern int futimens (int __fd, __const struct timespec __times[2]) throw ();
        extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
            throw () __attribute__ ((__nonnull__ (3)));
        extern int __xstat (int __ver, __const char *__filename,
                struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int __lxstat (int __ver, __const char *__filename,
                struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int __fxstatat (int __ver, int __fildes, __const char *__filename,
                struct stat *__stat_buf, int __flag)
            throw () __attribute__ ((__nonnull__ (3, 4)));
        extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
            throw () __attribute__ ((__nonnull__ (3)));
        extern int __xstat64 (int __ver, __const char *__filename,
                struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int __lxstat64 (int __ver, __const char *__filename,
                struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
        extern int __fxstatat64 (int __ver, int __fildes, __const char *__filename,
                struct stat64 *__stat_buf, int __flag)
            throw () __attribute__ ((__nonnull__ (3, 4)));
        extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
                __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
        extern int __xmknodat (int __ver, int __fd, __const char *__path,
                __mode_t __mode, __dev_t *__dev)
            throw () __attribute__ ((__nonnull__ (3, 5)));
    }
    struct ev_loop;
    enum {
        EV_UNDEF = (int)0xFFFFFFFF,
        EV_NONE = 0x00,
        EV_READ = 0x01,
        EV_WRITE = 0x02,
        EV__IOFDSET = 0x80,
        EV_IO = EV_READ,
        EV_TIMER = 0x00000100,
        EV_TIMEOUT = EV_TIMER,
        EV_PERIODIC = 0x00000200,
        EV_SIGNAL = 0x00000400,
        EV_CHILD = 0x00000800,
        EV_STAT = 0x00001000,
        EV_IDLE = 0x00002000,
        EV_PREPARE = 0x00004000,
        EV_CHECK = 0x00008000,
        EV_EMBED = 0x00010000,
        EV_FORK = 0x00020000,
        EV_CLEANUP = 0x00040000,
        EV_ASYNC = 0x00080000,
        EV_CUSTOM = 0x01000000,
        EV_ERROR = (int)0x80000000
    };
    typedef struct ev_watcher
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher *w, int revents);
    } ev_watcher;
    typedef struct ev_watcher_list
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_list *w, int revents); struct ev_watcher_list *next;
    } ev_watcher_list;
    typedef struct ev_watcher_time
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_time *w, int revents); ev_tstamp at;
    } ev_watcher_time;
    typedef struct ev_io
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_io *w, int revents); struct ev_watcher_list *next;
        int fd;
        int events;
    } ev_io;
    typedef struct ev_timer
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_timer *w, int revents); ev_tstamp at;
        ev_tstamp repeat;
    } ev_timer;
    typedef struct ev_periodic
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_periodic *w, int revents); ev_tstamp at;
        ev_tstamp offset;
        ev_tstamp interval;
        ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) throw();
    } ev_periodic;
    typedef struct ev_signal
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_signal *w, int revents); struct ev_watcher_list *next;
        int signum;
    } ev_signal;
    typedef struct ev_child
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_child *w, int revents); struct ev_watcher_list *next;
        int flags;
        int pid;
        int rpid;
        int rstatus;
    } ev_child;
    typedef struct stat ev_statdata;
    typedef struct ev_stat
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_stat *w, int revents); struct ev_watcher_list *next;
        ev_timer timer;
        ev_tstamp interval;
        const char *path;
        ev_statdata prev;
        ev_statdata attr;
        int wd;
    } ev_stat;
    typedef struct ev_idle
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_idle *w, int revents);
    } ev_idle;
    typedef struct ev_prepare
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_prepare *w, int revents);
    } ev_prepare;
    typedef struct ev_check
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_check *w, int revents);
    } ev_check;
    typedef struct ev_fork
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_fork *w, int revents);
    } ev_fork;
    typedef struct ev_cleanup
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_cleanup *w, int revents);
    } ev_cleanup;
    typedef struct ev_embed
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_embed *w, int revents);
        struct ev_loop *other;
        ev_io io;
        ev_prepare prepare;
        ev_check check;
        ev_timer timer;
        ev_periodic periodic;
        ev_idle idle;
        ev_fork fork;
        ev_cleanup cleanup;
    } ev_embed;
    typedef struct ev_async
    {
        int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_async *w, int revents);
        sig_atomic_t volatile sent;
    } ev_async;
    union ev_any_watcher
    {
        struct ev_watcher w;
        struct ev_watcher_list wl;
        struct ev_io io;
        struct ev_timer timer;
        struct ev_periodic periodic;
        struct ev_signal signal;
        struct ev_child child;
        struct ev_stat stat;
        struct ev_idle idle;
        struct ev_prepare prepare;
        struct ev_check check;
        struct ev_fork fork;
        struct ev_cleanup cleanup;
        struct ev_embed embed;
        struct ev_async async;
    };
    enum {
        EVFLAG_AUTO = 0x00000000U,
        EVFLAG_NOENV = 0x01000000U,
        EVFLAG_FORKCHECK = 0x02000000U,
        EVFLAG_NOINOTIFY = 0x00100000U,
        EVFLAG_NOSIGFD = 0,
        EVFLAG_SIGNALFD = 0x00200000U,
        EVFLAG_NOSIGMASK = 0x00400000U
    };
    enum {
        EVBACKEND_SELECT = 0x00000001U,
        EVBACKEND_POLL = 0x00000002U,
        EVBACKEND_EPOLL = 0x00000004U,
        EVBACKEND_KQUEUE = 0x00000008U,
        EVBACKEND_DEVPOLL = 0x00000010U,
        EVBACKEND_PORT = 0x00000020U,
        EVBACKEND_ALL = 0x0000003FU,
        EVBACKEND_MASK = 0x0000FFFFU
    };
    extern int ev_version_major (void) throw();
    extern int ev_version_minor (void) throw();
    extern unsigned int ev_supported_backends (void) throw();
    extern unsigned int ev_recommended_backends (void) throw();
    extern unsigned int ev_embeddable_backends (void) throw();
    extern ev_tstamp ev_time (void) throw();
    extern void ev_sleep (ev_tstamp delay) throw();
    extern void ev_set_allocator (void *(*cb)(void *ptr, long size) throw()) throw();
    extern void ev_set_syserr_cb (void (*cb)(const char *msg) throw()) throw();
    extern struct ev_loop *ev_default_loop (unsigned int flags = 0) throw();
    static inline struct ev_loop *
        ev_default_loop_uc_ (void) throw()
        {
            extern struct ev_loop *ev_default_loop_ptr;
            return ev_default_loop_ptr;
        }
    static inline int
        ev_is_default_loop (struct ev_loop *loop) throw()
        {
            return loop == ev_default_loop_uc_ ();
        }
    extern struct ev_loop *ev_loop_new (unsigned int flags = 0) throw();
    extern ev_tstamp ev_now (struct ev_loop *loop) throw();
    extern void ev_loop_destroy (struct ev_loop *loop);
    extern void ev_loop_fork (struct ev_loop *loop) throw();
    extern unsigned int ev_backend (struct ev_loop *loop) throw();
    extern void ev_now_update (struct ev_loop *loop) throw();
    enum {
        EVRUN_NOWAIT = 1,
        EVRUN_ONCE = 2
    };
    enum {
        EVBREAK_CANCEL = 0,
        EVBREAK_ONE = 1,
        EVBREAK_ALL = 2
    };
    extern int ev_run (struct ev_loop *loop, int flags = 0);
    extern void ev_break (struct ev_loop *loop, int how = EVBREAK_ONE) throw();
    extern void ev_ref (struct ev_loop *loop) throw();
    extern void ev_unref (struct ev_loop *loop) throw();
    extern void ev_once (struct ev_loop *loop, int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) throw();
    extern unsigned int ev_iteration (struct ev_loop *loop) throw();
    extern unsigned int ev_depth (struct ev_loop *loop) throw();
    extern void ev_verify (struct ev_loop *loop) throw();
    extern void ev_set_io_collect_interval (struct ev_loop *loop, ev_tstamp interval) throw();
    extern void ev_set_timeout_collect_interval (struct ev_loop *loop, ev_tstamp interval) throw();
    extern void ev_set_userdata (struct ev_loop *loop, void *data) throw();
    extern void *ev_userdata (struct ev_loop *loop) throw();
    extern void ev_set_invoke_pending_cb (struct ev_loop *loop, void (*invoke_pending_cb)(struct ev_loop *loop)) throw();
    extern void ev_set_loop_release_cb (struct ev_loop *loop, void (*release)(struct ev_loop *loop), void (*acquire)(struct ev_loop *loop) throw()) throw();
    extern unsigned int ev_pending_count (struct ev_loop *loop) throw();
    extern void ev_invoke_pending (struct ev_loop *loop);
    extern void ev_suspend (struct ev_loop *loop) throw();
    extern void ev_resume (struct ev_loop *loop) throw();
    extern void ev_feed_event (struct ev_loop *loop, void *w, int revents) throw();
    extern void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents) throw();
    extern void ev_feed_signal (int signum) throw();
    extern void ev_feed_signal_event (struct ev_loop *loop, int signum) throw();
    extern void ev_invoke (struct ev_loop *loop, void *w, int revents);
    extern int ev_clear_pending (struct ev_loop *loop, void *w) throw();
    extern void ev_io_start (struct ev_loop *loop, ev_io *w) throw();
    extern void ev_io_stop (struct ev_loop *loop, ev_io *w) throw();
    extern void ev_timer_start (struct ev_loop *loop, ev_timer *w) throw();
    extern void ev_timer_stop (struct ev_loop *loop, ev_timer *w) throw();
    extern void ev_timer_again (struct ev_loop *loop, ev_timer *w) throw();
    extern ev_tstamp ev_timer_remaining (struct ev_loop *loop, ev_timer *w) throw();
    extern void ev_periodic_start (struct ev_loop *loop, ev_periodic *w) throw();
    extern void ev_periodic_stop (struct ev_loop *loop, ev_periodic *w) throw();
    extern void ev_periodic_again (struct ev_loop *loop, ev_periodic *w) throw();
    extern void ev_signal_start (struct ev_loop *loop, ev_signal *w) throw();
    extern void ev_signal_stop (struct ev_loop *loop, ev_signal *w) throw();
    extern void ev_child_start (struct ev_loop *loop, ev_child *w) throw();
    extern void ev_child_stop (struct ev_loop *loop, ev_child *w) throw();
    extern void ev_stat_start (struct ev_loop *loop, ev_stat *w) throw();
    extern void ev_stat_stop (struct ev_loop *loop, ev_stat *w) throw();
    extern void ev_stat_stat (struct ev_loop *loop, ev_stat *w) throw();
    extern void ev_idle_start (struct ev_loop *loop, ev_idle *w) throw();
    extern void ev_idle_stop (struct ev_loop *loop, ev_idle *w) throw();
    extern void ev_prepare_start (struct ev_loop *loop, ev_prepare *w) throw();
    extern void ev_prepare_stop (struct ev_loop *loop, ev_prepare *w) throw();
    extern void ev_check_start (struct ev_loop *loop, ev_check *w) throw();
    extern void ev_check_stop (struct ev_loop *loop, ev_check *w) throw();
    extern void ev_fork_start (struct ev_loop *loop, ev_fork *w) throw();
    extern void ev_fork_stop (struct ev_loop *loop, ev_fork *w) throw();
    extern void ev_cleanup_start (struct ev_loop *loop, ev_cleanup *w) throw();
    extern void ev_cleanup_stop (struct ev_loop *loop, ev_cleanup *w) throw();
    extern void ev_embed_start (struct ev_loop *loop, ev_embed *w) throw();
    extern void ev_embed_stop (struct ev_loop *loop, ev_embed *w) throw();
    extern void ev_embed_sweep (struct ev_loop *loop, ev_embed *w) throw();
    extern void ev_async_start (struct ev_loop *loop, ev_async *w) throw();
    extern void ev_async_stop (struct ev_loop *loop, ev_async *w) throw();
    extern void ev_async_send (struct ev_loop *loop, ev_async *w) throw();
    static inline void ev_loop (struct ev_loop *loop, int flags) { ev_run (loop, flags); }
    static inline void ev_unloop (struct ev_loop *loop, int how ) { ev_break (loop, how ); }
    static inline void ev_default_destroy (void) { ev_loop_destroy (ev_default_loop (0)); }
    static inline void ev_default_fork (void) { ev_loop_fork (ev_default_loop (0)); }
    static inline unsigned int ev_loop_count (struct ev_loop *loop) { return ev_iteration (loop); }
    static inline unsigned int ev_loop_depth (struct ev_loop *loop) { return ev_depth (loop); }
    static inline void ev_loop_verify (struct ev_loop *loop) { ev_verify (loop); }
}
ev_io stdin_watcher;
ev_timer timeout_watcher;
static void stdin_cb (struct ev_loop *loop, ev_io *w, int revents)
{
    puts ("stdin ready");
    ev_io_stop (loop, w);
    ev_break (loop, EVBREAK_ALL);
}
static void timeout_cb (struct ev_loop *loop, ev_timer *w, int revents)
{
    puts ("timeout");
    ev_break (loop, EVBREAK_ONE);
}
int main(void)
{
    struct ev_loop *loop = ev_default_loop (0);

    do {
        do {
            ((ev_watcher *)(void *)((&stdin_watcher)))->active = ((ev_watcher *)(void *)((&stdin_watcher)))->pending = 0;
            ( (ev_watcher *)(void *)(((&stdin_watcher))))->priority = (0);
            (((&stdin_watcher)))->cb = ((stdin_cb));
        } while (0);
        
        do { 
            ((&stdin_watcher))->fd = ((0));
            ((&stdin_watcher))->events = ((EV_READ)) | EV__IOFDSET;
        } while (0);
    } while (0);

    ev_io_start (loop, &stdin_watcher);


    do { do { ((ev_watcher *)(void *)((&timeout_watcher)))->active = ((ev_watcher *)(void *)((&timeout_watcher)))->pending = 0; ( (ev_watcher *)(void *)(((&timeout_watcher))))->priority = (0); (((&timeout_watcher)))->cb = ((timeout_cb)); } while (0); do { ((ev_watcher_time *)((&timeout_watcher)))->at = ((5.5)); ((&timeout_watcher))->repeat = ((0.)); } while (0); } while (0);
    ev_timer_start (loop, &timeout_watcher);
    ev_run (loop, 0);
    return 0;
}
